/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package vigas.gui;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JPanel;
import vigas.calculos.controller.VigaCalculosController;
import vigas.componentes.Apoio;
import vigas.componentes.ApoioFixo;
import vigas.componentes.ApoioMovel;
import vigas.componentes.CargaAplicada;
import vigas.componentes.CargaDistribuida;
import vigas.componentes.Engaste;
import vigas.componentes.Momento;
import vigas.componentes.Viga;

/**
 *
 * @author Lidiany
 */
public class PainelDeDesenho extends JPanel implements MouseMotionListener {

    private boolean temComprimento = false;
    private boolean desenhoLivre = false;
    private boolean podeDesenharApoioFixo = false;
    private boolean podeDesenharApoioMovel = false;
    private boolean podeDesenharEngaste = false;
    private boolean podeDesenharForcaAplicada = false;
    private boolean podeDesenharForcaDistribuida = false;
    private boolean podeDesenharMomento = false;
    private boolean podeDesenharViga = false;
    private boolean podeMostrarComprimento = false;
    private boolean podeDesenharPonto = false;
    private boolean pintaPontosSelecionados = false;
    private boolean pintaApoiosSelecionados = false;
    private boolean pintaObjetosSelecionados = false;
    private int numeroDeClicks = 0; //esse é zerado a cada desenho
    private List<Point> listaDeClicks = new ArrayList<Point>();
    //componentes que serao adiconados
    private List<Point> pontos = new ArrayList<Point>();
    private List<Apoio> apoios = new ArrayList<Apoio>();
    private List<Point> pontosSelecionados = new ArrayList<Point>();
    private List<Apoio> apoiosSelecionados = new ArrayList<Apoio>();
    private CargaAplicada cargaAplicada = null;
    private CargaDistribuida cargaDistribuida = null;
    private Momento momento = null;
    float valorDaForca;
    private Viga viga = null;
    private VigasApp vigasApp;
    boolean podeArrastar = true;

    boolean arrastarForcaAp = false;
    boolean arrastarMomento = false;
    boolean arrastarDist = false;

    //variáveis para geração dos gráficos
    public List<Apoio> getApoios() {
        return apoios;
    }

    public PainelDeDesenho(VigasApp v) {
        vigasApp = v;
        //super.setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
        addMouseListeners();

    }

    private void addMouseListeners() {
        addMouseMotionListener(this);
        addMouseListener(new MouseAdapter() {

            @Override
            public void mouseClicked(MouseEvent e) {

                if (e.getClickCount() >= 1) {
                    numeroDeClicks++;
                    listaDeClicks.add(new Point(e.getX(), e.getY()));
                    repaint(); //E pedimos para o painel se repintar.
                }
            }

            @Override
            public void mouseReleased(MouseEvent e) {
                if (cargaAplicada != null || momento != null || cargaDistribuida != null) {
                    vigasApp.fazOsCalculos();
                }
            }
        });
    }

    @Override
    protected void paintComponent(Graphics g) {
        if (numeroDeClicks == 1) {
            //aqui desenha pontos força aplicada e apoios
            if (podeDesenharPonto) {
                desenharPonto(g, setDesenharPonto(pontos), Color.BLUE);

                //A linha seguinte insere os objetos no jScrollPaneListagem
                VigasApp.inserirTudo(pontos, apoios, cargaAplicada, cargaDistribuida, momento);

            } else if (podeMostrarComprimento) {
                // não limpa os pontos
            }
            else if (podeDesenharForcaAplicada) {
                if (viga != null && cargaAplicada == null) {
                    desenharForcaAplicada(g);

                    //A linha seguinte insere os objetos no jScrollPaneListagem
                    VigasApp.inserirTudo(pontos, apoios, cargaAplicada, cargaDistribuida, momento);

                } else {
                    podeDesenharForcaAplicada = false;
                }
            } else if (podeDesenharApoioFixo) {
                desenharApoioFixo(g);

                //A linha seguinte insere os objetos no jScrollPaneListagem
                VigasApp.inserirTudo(pontos, apoios, cargaAplicada, cargaDistribuida, momento);

            } else if (podeDesenharApoioMovel) {
                desenharApoioMovel(g);

                //A linha seguinte insere os objetos no jScrollPaneListagem
                VigasApp.inserirTudo(pontos, apoios, cargaAplicada, cargaDistribuida, momento);

            } else if (podeDesenharEngaste) {
                desenharEngaste(g);

                //A linha seguinte insere os objetos no jScrollPaneListagem
                VigasApp.inserirTudo(pontos, apoios, cargaAplicada, cargaDistribuida, momento);

            } else if (podeDesenharMomento) {
                //o momento pode ter duas direções né?
                //não sei como fzr isso ainda o.O
                //qqr coisa deixa pra dps!
                desenharMomento(g);
                 VigasApp.inserirTudo(pontos, apoios, cargaAplicada, cargaDistribuida, momento);
            } else if (podeDesenharViga) {
                //nao limpa os pontos
            } else if (podeDesenharForcaDistribuida) {
                //nao limpa os pontos
            } else {
                numeroDeClicks = 0;
            }
        } else if (numeroDeClicks == 2) {
            
            if (podeDesenharViga) {
                //agora desenha a viga toda
                if (pontos.size() >= 2) {
                    desenharViga(g);
                } else {
                    podeDesenharViga = false;
                }
            } else if (podeMostrarComprimento) {
                
                //agora desenha a viga toda
                if (pontos.size() >= 2) {
                   
                    mostrarComprimento(g);
                } else {
                    podeMostrarComprimento = false;
                }
            }
            else if (podeDesenharForcaDistribuida) {
                if (viga != null && cargaDistribuida == null) {
                    desenharForcaDistribuida(g);

                    //A linha seguinte insere os objetos no jScrollPaneListagem
                    VigasApp.inserirTudo(pontos, apoios, cargaAplicada, cargaDistribuida, momento);

                } else {
                    podeDesenharForcaDistribuida = false;
                }

            } else {
                numeroDeClicks = 0;

            }

        } else {
            numeroDeClicks = 0;

        }

        desenharTudo(g);

        if (pintaObjetosSelecionados) {
            desenharTudo(g);
            if (pintaPontosSelecionados) {
                g.setColor(Color.red);
                for (int i = 0; i < pontosSelecionados.size(); i++) {
                    g.fillOval(pontosSelecionados.get(i).x, pontosSelecionados.get(i).y, 8, 8);
                }
                pontosSelecionados.clear();
                pintaPontosSelecionados = false;
            }
            if (pintaApoiosSelecionados) {
                for (int i = 0; i < apoiosSelecionados.size(); i++) {
                    apoiosSelecionados.get(i).desenharApoio(g, Color.RED);
                }
                apoiosSelecionados.clear();
                pintaApoiosSelecionados = false;
            }
        }

//        if(this.viga!=null){
//           Graphics2D g2 = (Graphics2D) g.create();
//           g2.setColor(Color.BLACK);
//           int x=(int)viga.getPontosDaViga().get(0).getX();
//           g2.drawString("Tamanho da viga: "+this.getViga().comprimentoEmMetros()+"m", x , 0);
//           g2.dispose();
//        }
    }

    public void desenharForcaDistribuida(Graphics g) {


        int ultimoClick = listaDeClicks.size() - 1;
        Point pa = listaDeClicks.get(ultimoClick);

        Point pb = listaDeClicks.get(ultimoClick - 1);

        //verifica se está em cima da viga
        Point p0Viga = viga.getPontosDaViga().get(0);
        int ultimoPtodaViga = viga.getPontosDaViga().size() - 1;
        Point p1Viga = viga.getPontosDaViga().get(ultimoPtodaViga);

        if (((pa.x > p0Viga.x + 1 && pa.x <= p1Viga.x) && (pa.y >= p0Viga.y - 15 && pa.y <= p0Viga.y + 15)) && ((pb.x > p0Viga.x + 1 && pb.x <= p1Viga.x) && (pb.y >= p0Viga.y - 15 && pb.y <= p0Viga.y + 15))) {

            List<Point> ptsCarga = new ArrayList<Point>(2);
            pa.y = p0Viga.y + 2;
            pb.y = p0Viga.y + 2;
            ptsCarga.add(pb);
            ptsCarga.add(pa);

            cargaDistribuida = new CargaDistribuida();
            //o valor da carga vai ser metade da 'largura'
            cargaDistribuida.setValorDaCarga(valorDaForca);
            cargaDistribuida.setPontosDaCarga(ptsCarga);
            cargaDistribuida.desenharCarga(g);

            //limpa os cliques e libera o desenho
            numeroDeClicks = 0;
            vigasApp.fazOsCalculos();
            podeDesenharForcaDistribuida = false;
        }
    }

    public Viga getViga() {
        return viga;
    }

    public CargaAplicada getCargaAplicada() {
        return cargaAplicada;
    }

    public void setCargaAplicada(Object reset) {
        cargaAplicada = (CargaAplicada) reset;
    }

    public void setCargaDistribuida(Object reset) {
        cargaDistribuida = (CargaDistribuida) reset;
    }

    public void setMomento(Object reset) {
        momento = (Momento) reset;
    }

    public Momento getMomento() {
        return momento;
    }

    public CargaDistribuida getCargaDistribuida() {
        return cargaDistribuida;
    }

    public void desenharForcaAplicada(Graphics g) {
        int ultimoClick = listaDeClicks.size() - 1;
        Point pa = listaDeClicks.get(ultimoClick);

        //verifica se está em cima da viga
        Point p0Viga = viga.getPontosDaViga().get(0);
        int ultimoPtodaViga = viga.getPontosDaViga().size() - 1;
        Point p1Viga = viga.getPontosDaViga().get(ultimoPtodaViga);

        if ((pa.x > p0Viga.x + 1 && pa.x <= p1Viga.x) && (pa.y >= p0Viga.y - 15 && pa.y <= p0Viga.y + 15)) {

            cargaAplicada = new CargaAplicada();
            cargaAplicada.setValorDaCarga(valorDaForca);
            pa.y = p0Viga.y - 2;
            cargaAplicada.setPontoMarcadoNaviga(pa);
            cargaAplicada.desenharCarga(g);

            podeDesenharForcaAplicada = false;
            vigasApp.fazOsCalculos();

        }
        numeroDeClicks = 0;
    }

    public void desenharMomento(Graphics g) {

        if (viga == null) {
            numeroDeClicks = 0;
            podeDesenharMomento = false;
            return;
        }

        int ultimoClick = listaDeClicks.size() - 1;
        Point pa = listaDeClicks.get(ultimoClick);

        //verifica se está em cima da viga
        Point p0Viga = viga.getPontosDaViga().get(0);
        int ultimoPtodaViga = viga.getPontosDaViga().size() - 1;
        Point p1Viga = viga.getPontosDaViga().get(ultimoPtodaViga);

        if ((pa.x > p0Viga.x + 1 && pa.x <= p1Viga.x) && (pa.y >= p0Viga.y - 15 && pa.y <= p0Viga.y + 15)) {

            pa.y = p0Viga.y;
            momento = new Momento();
            momento.setPontoMarcadoNaviga(pa);
            momento.setValorDoMomento(valorDaForca);
            momento.desenharCarga(g);
            podeDesenharMomento = false;
        }

        vigasApp.fazOsCalculos();
        //limpa os cliques e libera o desenho
        numeroDeClicks = 0;

    }

    public void desenharApoioFixo(Graphics g) {
        if (apoios.size() == 2) {
            return;
        }

        int ultimoClick = listaDeClicks.size() - 1;
        Point pa = listaDeClicks.get(ultimoClick);
        for (Point p : pontos) {
            if (pontosSaoProximos(pa, p)) {
                ApoioFixo apoioFixo = new ApoioFixo();
                pa.x = p.x + 4;
                pa.y = p.y;
                apoioFixo.setPontoMarcadoNaviga(pa);
                apoioFixo.desenharApoio(g, Color.BLACK);
                apoios.add(apoioFixo);
                //limpa os cliques e libera o desenho
                podeDesenharApoioFixo = false;
            }
        }
        numeroDeClicks = 0;
    }

    public void desenharApoioMovel(Graphics g) {
        if (apoios.size() == 2) {
            return;
        }

        int ultimoClick = listaDeClicks.size() - 1;
        Point pa = listaDeClicks.get(ultimoClick);
        for (Point p : pontos) {
            if (pontosSaoProximos(pa, p)) {
                ApoioMovel apoioMovel = new ApoioMovel();
                pa.x = p.x + 4;
                pa.y = p.y;
                apoioMovel.setPontoMarcadoNaviga(pa);
                apoioMovel.desenharApoio(g, Color.BLACK);
                apoios.add(apoioMovel);
                podeDesenharApoioMovel = false;
            }
        }
        //limpa os cliques e libera o desenho
        numeroDeClicks = 0;

    }

    public void desenharEngaste(Graphics g) {
        if (apoios.size() == 2) {
            return;
        }

        int ultimoClick = listaDeClicks.size() - 1;
        Point pa = listaDeClicks.get(ultimoClick);
        for (Point p : pontos) {
            if (pontosSaoProximos(pa, p)) {
                Engaste engaste = new Engaste();

                if (viga != null) {
                    //Point p0 = viga.getPontosDaViga().get(0);
                    Point p1 = viga.getPontosDaViga().get(1);

                    if (pontosSaoProximos(pa, p1)) {
                        engaste.setEngasteEsq(false);
                    }
                }

                pa.x = p.x + 4;
                pa.y = p.y;
                engaste.setPontoMarcadoNaviga(pa);
                engaste.desenharApoio(g, Color.BLACK);
                apoios.add(engaste);
                podeDesenharEngaste = false;
            }
        }
        //limpa os cliques e libera o desenho
        numeroDeClicks = 0;



    }

    public void desenharViga(Graphics g) {
        //super.paintComponent(g);

        int ultimoClick = listaDeClicks.size() - 1;
        Point pa = listaDeClicks.get(ultimoClick);

        int penultimoClick = listaDeClicks.size() - 2;
        Point pb = listaDeClicks.get(penultimoClick);


        int ptsOk = 0;

        for (int i = 0; i < pontos.size(); i++) {

            if (pontosSaoProximos(pa, pontos.get(i))) {
                pa = pontos.get(i);
                ptsOk++;
            }
            if (pontosSaoProximos(pb, pontos.get(i))) {
                pb = pontos.get(i);
                ptsOk++;
            }
        }




        if (ptsOk != 2) {
            //podeDesenharViga = false;
            numeroDeClicks = 0;
            return;
        }
        
        if (viga == null) {
            this.viga = new Viga();
        }

        viga.desenharViga(g, pa, pb, !desenhoLivre);
        //limpa os cliques e libera o desenho
        numeroDeClicks = 0;
        podeDesenharViga = false;
    }

    public void mostrarComprimento(Graphics g) {
        //super.paintComponent(g);

        int ultimoClick = listaDeClicks.size() - 1;
        Point pa = listaDeClicks.get(ultimoClick);

        int penultimoClick = listaDeClicks.size() - 2;
        Point pb = listaDeClicks.get(penultimoClick);


        int ptsOk = 0;

        for (int i = 0; i < pontos.size(); i++) {

            if (pontosSaoProximos(pa, pontos.get(i))) {
                 
                pa = pontos.get(i);
                ptsOk++;
            }
            if (pontosSaoProximos(pb, pontos.get(i))) {
                pb = pontos.get(i);
                ptsOk++;
            }
        }




        if (ptsOk != 2) {
            //podeDesenharViga = false;
            numeroDeClicks = 0;
            return;
        }
        

       // System.out.println("CHEGOU AQUI 2");

        if (viga == null) {
            //this.viga = new Viga();
            return;
        }

        viga.mostrarComprimento(g, pa, pb, !desenhoLivre);
       

        //limpa os cliques e libera o desenho
        numeroDeClicks = 0;
        temComprimento = true;
        podeMostrarComprimento = false;
    }

    public List<Point> setDesenharPonto(List<Point> pontos) {

        int ultimoClick = listaDeClicks.size() - 1;
        Point ponto = listaDeClicks.get(ultimoClick);

        if (!desenhoLivre && pontos.size() >= 1) {
            ponto.y = pontos.get(0).y;
            pontos.add(ponto);
        } else {
            pontos.add(ponto);
        }
        return pontos;
    }

    public void desenharPonto(Graphics g, List<Point> pontos, Color cor) {

        Graphics2D g2 = (Graphics2D) g.create();
        super.paintComponent(g);
        g2.setColor(cor);
        for (Point p : pontos) {
            g2.fillOval(p.x, p.y, 8, 8);
        }

        //limpa os cliques e libera o desenho
        numeroDeClicks = 0;
        podeDesenharPonto = false;
        g2.dispose();
    }

    public void mouseDragged(MouseEvent e) {
        //pega o pto do click
        Point ptoClicado = e.getPoint();

        if(podeArrastar){
            arrastarMomento = false;
            arrastarForcaAp = false;
            arrastarDist = false;
        }

        if ((cargaAplicada != null) && (!arrastarMomento) && (!arrastarDist)) {
            Point p2 = cargaAplicada.getPontoMarcadoNaviga();
            if ((Math.abs(p2.x - ptoClicado.x) < 10 && Math.abs(p2.y - ptoClicado.y) < 50)) {

                //verifica se está em cima da viga
                Point p0Viga = viga.getPontosDaViga().get(0);
                int ultimoPtodaViga = viga.getPontosDaViga().size() - 1;
                Point p1Viga = viga.getPontosDaViga().get(ultimoPtodaViga);

                if (ptoClicado.x > p0Viga.x + 3 && ptoClicado.x <= p1Viga.x + 1) {
                    if (podeArrastar || arrastarForcaAp) {
                        arrastarForcaAp = true;
                        arrastarMomento = false;
                        arrastarDist = false;
                        cargaAplicada.alterarCoordX(ptoClicado.x);
                        podeArrastar = false;
                    }
                }
                VigasApp.inserirTudo(pontos, apoios, cargaAplicada, cargaDistribuida, momento);
                repaint();
            }
        }

        if ((momento != null) && (!arrastarForcaAp) && (!arrastarDist)) {
            Point p2 = momento.getPontoMarcadoNaviga();
            if ((Math.abs(p2.x - ptoClicado.x) < 10 && Math.abs(p2.y - ptoClicado.y) < 50)) {

                //verifica se está em cima da viga
                Point p0Viga = viga.getPontosDaViga().get(0);
                int ultimoPtodaViga = viga.getPontosDaViga().size() - 1;
                Point p1Viga = viga.getPontosDaViga().get(ultimoPtodaViga);

                if (ptoClicado.x > p0Viga.x + 3 && ptoClicado.x <= p1Viga.x +1) {
                    if (podeArrastar || arrastarMomento) {
                        arrastarMomento = true;
                        arrastarForcaAp = false;
                        arrastarDist = false;
                        momento.alterarCoordX(ptoClicado.x);
                        podeArrastar = false;
                    }

                }
                VigasApp.inserirTudo(pontos, apoios, cargaAplicada, cargaDistribuida, momento);
                repaint();
            }
        }

        if ((cargaDistribuida != null) && (!arrastarMomento) && (!arrastarForcaAp)) {

            //verifica se está em cima da viga
            Point p0Viga = viga.getPontosDaViga().get(0);
            int ultimoPtodaViga = viga.getPontosDaViga().size() - 1;
            Point p1Viga = viga.getPontosDaViga().get(ultimoPtodaViga);
            //ve se o 'arraste' ainda tá dentro da viga
            if ((ptoClicado.x > p0Viga.x + 2 && ptoClicado.x <= p1Viga.x +2) //pt x
                    && (ptoClicado.y >= p0Viga.y - 30 && ptoClicado.y <= p0Viga.y+2)) {
                //olha qual parte tá sendo arrastada
                int meioDaforca = cargaDistribuida.getPontosDaCarga().get(0).x + cargaDistribuida.getMetadeDaForca();
                if (ptoClicado.x <= meioDaforca) {
                    ptoClicado.y = cargaDistribuida.getPontosDaCarga().get(0).y;
                    cargaDistribuida.getPontosDaCarga().set(0, ptoClicado);
                } else if (ptoClicado.x > meioDaforca) {
                    ptoClicado.y = cargaDistribuida.getPontosDaCarga().get(1).y;
                    cargaDistribuida.getPontosDaCarga().set(1, ptoClicado);
                }
                if (podeArrastar || arrastarDist) {
                   VigasApp.inserirTudo(pontos, apoios, cargaAplicada, cargaDistribuida, momento);
                    arrastarMomento = false;
                    arrastarForcaAp = false;
                    arrastarDist = true;
                    podeArrastar = false;
                    repaint();
                }

            }
        }
    }

    public void mouseMoved(MouseEvent e) {

        if (viga != null) {
            try {
                Point ponto = e.getPoint();
                exibirEsforcoEMomento(ponto);
            } catch (Exception ex) {
            }
        }

        podeArrastar = true;
    }

    private void exibirEsforcoEMomento(Point ponto) {
        VigaCalculosController vigaC = VigaCalculosController.getInstance(this);


        Point p0Viga = viga.getPontosDaViga().get(0);
        int ultimoPtodaViga = viga.getPontosDaViga().size() - 1;
        Point p1Viga = viga.getPontosDaViga().get(ultimoPtodaViga);
        NumberFormat numberFormat = new DecimalFormat("#.##");
        int pontoDaViga = ponto.x - p0Viga.x;
        pontoDaViga++;
        if (ponto.x > p0Viga.x + 1 && ponto.x < p1Viga.x) {
            if (vigaC.mSum.length > 0) {


                String esforco = numberFormat.format(vigaC.vSum[pontoDaViga]);
                String vlrMomento = numberFormat.format(vigaC.mSum[pontoDaViga]);


                this.setToolTipText("x: " + (float) pontoDaViga / 100 + "m\n | Mom. fletor " + vlrMomento + "\n | Esf. cort. " + esforco);

                this.repaint();
            }
        } else if (ponto.x < p0Viga.x) {
            if (vigaC.mSum.length > 0 && vigaC.vSum.length > 0) {

                String esforco = numberFormat.format(vigaC.vSum[0]);
                String vlrMomento = numberFormat.format(vigaC.mSum[0]);
                pontoDaViga = 0;


                this.setToolTipText("x: " + (float) pontoDaViga / 100 + "m\n | Mom. fletor " + vlrMomento + "\n | Esf. cort. " + esforco);

                this.repaint();
            }
        } else if (ponto.x > p1Viga.x) {
            if (vigaC.mSum.length > 0 && vigaC.vSum.length > 0) {

                int compDaViga = viga.getQtdDePontos() - 1;
                String esforco = numberFormat.format(vigaC.vSum[compDaViga]);
                String vlrMomento = numberFormat.format(vigaC.mSum[compDaViga]);
                pontoDaViga = viga.getQtdDePontos() - 1;


                this.setToolTipText("x: " + (float) pontoDaViga / 100 + "m\n | Mom. fletor " + vlrMomento + "\n | Esf. cort. " + esforco);

                this.repaint();
            }
        }
    }

    private void desenharTudo(Graphics g) {

        Graphics2D g2 = (Graphics2D) g.create();
        super.paintComponent(g);
        g2.setColor(Color.BLUE);

        for (Apoio ap : apoios) {
            ap.desenharApoio(g, Color.BLACK);
        }

        if (viga != null) {
            viga.desenharViga(g, !desenhoLivre);
            
        }

        if (viga != null && temComprimento) {
            viga.mostrarComprimento(g);
        }

        for (Point p : pontos) {
            g2.fillOval(p.x, p.y, 8, 8);
        }

        if (cargaDistribuida != null) {
            cargaDistribuida.desenharCarga(g);
        }

        if (cargaAplicada != null) {
            cargaAplicada.desenharCarga(g);
        }

        if (momento != null) {
            momento.desenharCarga(g);
        }

        g2.dispose();

    }

    public List<Point> getPontos() {
        return pontos;
    }

    private boolean pontosSaoProximos(Point p1, Point p2) {

        if ((Math.abs(p2.x - p1.x) <= 8) && (Math.abs(p2.y - p1.y) <= 8)) {
            return true;
        }
        return false;
    }

    public void setDesenhoLivre(boolean desenhoLivre) {
        this.desenhoLivre = desenhoLivre;
    }

    public void setPodeDesenharApoioFixo(boolean podeDesenharApoioFixo) {
        this.podeDesenharApoioFixo = podeDesenharApoioFixo;
    }

    public void setPodeDesenharApoioMovel(boolean podeDesenharApoioMovel) {
        this.podeDesenharApoioMovel = podeDesenharApoioMovel;
    }

    public void setPodeDesenharEngaste(boolean podeDesenharEngaste) {
        this.podeDesenharEngaste = podeDesenharEngaste;
    }

    public void setPodeDesenharForcaAplicada(boolean podeDesenharForcaAplicada) {
        this.podeDesenharForcaAplicada = podeDesenharForcaAplicada;
    }

    public void setPodeDesenharForcaDistribuida(boolean podeDesenharForcaDistribuida) {
        this.podeDesenharForcaDistribuida = podeDesenharForcaDistribuida;
    }

    public void setPodeDesenharMomento(boolean podeDesenharMomento) {
        this.podeDesenharMomento = podeDesenharMomento;
    }

    public void setPodeDesenharPonto(boolean podeDesenharPonto) {
        this.podeDesenharPonto = podeDesenharPonto;
    }

    public void setPodeDesenharViga(boolean podeDesenharViga) {
        this.podeDesenharViga = podeDesenharViga;
    }

    public void setPodeMostrarComprimento(boolean podeMostrarComprimento) {
        this.podeMostrarComprimento = podeMostrarComprimento;
    }

    public void setValorDaForca(float valorDaForca) {
        this.valorDaForca = valorDaForca;
    }

    void setPontosSelecionados(Point get) {
        pontosSelecionados.add(get);
        setPintaPontosSelecionados(true);
    }

    void setApoiosSelecionados(Apoio a) {
        apoiosSelecionados.add(a);
        setPintaApoiosSelecionados(true);
    }

    void setPintaPontosSelecionados(boolean pintaSelecionado) {
        this.pintaPontosSelecionados = pintaSelecionado;
    }

    void setPintaApoiosSelecionados(boolean pintaSelecionado) {
        this.pintaApoiosSelecionados = pintaSelecionado;
    }

    void setPintaObjetosSelecionados(boolean b) {
        this.pintaObjetosSelecionados = b;
    }

    void deletarPonto(int posicao) {
        this.pontos.remove(posicao);
    }

    void deletarApoio(int posicao) {
        this.apoios.remove(posicao);
    }
}